#include "../include/test_framework.h"
#include <sys/stat.h>
#include <fcntl.h>
#include <stdarg.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>

// 全局变量
static int server_fifo_fd = -1;
static int client_fifo_fd = -1;
static FILE *log_file = NULL;

// 后台服务日志
void daemon_log(const char *level, const char *format, ...) {
    if (!log_file) {
        log_file = fopen("/tmp/ai_glass_daemon.log", "a");
        if (!log_file) return;
    }
    
    time_t now = time(NULL);
    struct tm *tm_info = localtime(&now);
    
    fprintf(log_file, "[%04d-%02d-%02d %02d:%02d:%02d] [%s] ",
           tm_info->tm_year + 1900, tm_info->tm_mon + 1, tm_info->tm_mday,
           tm_info->tm_hour, tm_info->tm_min, tm_info->tm_sec, level);
    
    va_list args;
    va_start(args, format);
    vfprintf(log_file, format, args);
    va_end(args);
    
    fprintf(log_file, "\n");
    fflush(log_file);
}

// 创建命名管道
int create_fifos(void) {
    // 删除可能存在的旧管道
    unlink(FIFO_SERVER_PATH);
    unlink(FIFO_CLIENT_PATH);
    
    // 创建服务器端管道 (接收命令)
    if (mkfifo(FIFO_SERVER_PATH, 0666) == -1) {
        daemon_log("ERROR", "创建服务器管道失败: %s", strerror(errno));
        return -1;
    }
    
    // 创建客户端管道 (发送响应)
    if (mkfifo(FIFO_CLIENT_PATH, 0666) == -1) {
        daemon_log("ERROR", "创建客户端管道失败: %s", strerror(errno));
        unlink(FIFO_SERVER_PATH);
        return -1;
    }
    
    daemon_log("INFO", "命名管道创建成功");
    return 0;
}

// 清理资源
void cleanup_daemon(void) {
    if (server_fifo_fd >= 0) {
        close(server_fifo_fd);
        server_fifo_fd = -1;
    }
    
    if (client_fifo_fd >= 0) {
        close(client_fifo_fd);
        client_fifo_fd = -1;
    }
    
    unlink(FIFO_SERVER_PATH);
    unlink(FIFO_CLIENT_PATH);
    
    if (log_file) {
        fclose(log_file);
        log_file = NULL;
    }
    
    daemon_log("INFO", "资源清理完成");
}

// 处理客户端命令
void handle_client_command(const char *cmd_line) {
    test_command_t cmd;
    test_result_t result;
    char response[MAX_FIFO_MSG_LEN];
    
    daemon_log("INFO", "收到命令: %s", cmd_line);
    
    // 解析命令
    if (parse_command_parameters(cmd_line, &cmd) != 0) {
        snprintf(response, sizeof(response), "ERROR: 命令解析失败");
        daemon_log("WARN", "命令解析失败: %s", cmd_line);
    } else {
        // 处理退出命令
        if (cmd.type == CMD_EXIT) {
            snprintf(response, sizeof(response), "OK: 后台服务正在停止");
            daemon_log("INFO", "收到退出命令，准备停止服务");
            
            // 发送响应后退出
            if (client_fifo_fd >= 0) {
                write(client_fifo_fd, response, strlen(response) + 1);
            }
            
            g_test_framework.running = 0;
            return;
        }
        
        // 处理其他命令
        result = process_command(&cmd);
        snprintf(response, sizeof(response), "OK: %s -> %s", 
                cmd.cmd_string, get_result_string(result));
        
        daemon_log("INFO", "命令处理完成: %s [%s]", 
                  cmd.cmd_string, get_result_string(result));
    }
    
    // 发送响应
    if (client_fifo_fd >= 0) {
        ssize_t written = write(client_fifo_fd, response, strlen(response) + 1);
        if (written < 0) {
            daemon_log("ERROR", "发送响应失败: %s", strerror(errno));
        }
    }
}

// 后台服务主循环
void* daemon_command_loop(void *arg) {
    (void)arg; // 抑制未使用参数警告
    char buffer[MAX_FIFO_MSG_LEN];
    ssize_t bytes_read;
    
    daemon_log("INFO", "命令处理循环已启动");
    
    while (g_test_framework.running) {
        // 打开服务器管道读取命令
        server_fifo_fd = open(FIFO_SERVER_PATH, O_RDONLY);
        if (server_fifo_fd < 0) {
            daemon_log("ERROR", "打开服务器管道失败: %s", strerror(errno));
            break;
        }
        
        // 打开客户端管道发送响应
        client_fifo_fd = open(FIFO_CLIENT_PATH, O_WRONLY);
        if (client_fifo_fd < 0) {
            daemon_log("ERROR", "打开客户端管道失败: %s", strerror(errno));
            close(server_fifo_fd);
            break;
        }
        
        // 读取命令
        bytes_read = read(server_fifo_fd, buffer, sizeof(buffer) - 1);
        if (bytes_read > 0) {
            buffer[bytes_read] = '\0';
            
            // 去除换行符
            char *newline = strchr(buffer, '\n');
            if (newline) *newline = '\0';
            
            // 处理命令
            if (strlen(buffer) > 0) {
                handle_client_command(buffer);
            }
        } else if (bytes_read == 0) {
            // 客户端关闭连接
            daemon_log("DEBUG", "客户端断开连接");
        } else {
            daemon_log("ERROR", "读取命令失败: %s", strerror(errno));
        }
        
        // 关闭文件描述符
        close(server_fifo_fd);
        close(client_fifo_fd);
        server_fifo_fd = -1;
        client_fifo_fd = -1;
    }
    
    daemon_log("INFO", "命令处理循环已停止");
    return NULL;
}

// 后台服务信号处理
void daemon_signal_handler(int sig) {
    daemon_log("INFO", "收到信号 %d，准备停止服务", sig);
    g_test_framework.running = 0;
}

// 启动后台服务
int start_background_service(void) {
    daemon_log("INFO", "启动AI Glass后台服务");
    
    // 设置信号处理
    signal(SIGTERM, daemon_signal_handler);
    signal(SIGINT, daemon_signal_handler);
    signal(SIGPIPE, SIG_IGN);
    
    // 创建命名管道
    if (create_fifos() != 0) {
        return -1;
    }
    
    // 初始化测试框架
    if (test_framework_init() != 0) {
        daemon_log("ERROR", "测试框架初始化失败");
        cleanup_daemon();
        return -1;
    }
    
    // 设置为后台模式
    g_test_framework.interactive_mode = 0;
    g_test_framework.running = 1;
    
    // 启动命令处理线程 (不需要输入解析线程)
    if (pthread_create(&g_test_framework.cmd_processor_thread, NULL, 
                      daemon_command_loop, NULL) != 0) {
        daemon_log("ERROR", "创建命令处理线程失败");
        cleanup_daemon();
        return -1;
    }
    
    // 启动监控线程
    if (pthread_create(&g_test_framework.monitor_thread, NULL, 
                      monitor_thread, NULL) != 0) {
        daemon_log("ERROR", "创建监控线程失败");
        cleanup_daemon();
        return -1;
    }
    
    daemon_log("INFO", "后台服务启动完成");
    
    // 创建服务状态文件
    FILE *status_file = fopen("/tmp/ai_glass_daemon.pid", "w");
    if (status_file) {
        fprintf(status_file, "%d\n", getpid());
        fclose(status_file);
    }
    
    // 主循环
    while (g_test_framework.running) {
        sleep(1);
    }
    
    // 清理资源
    pthread_join(g_test_framework.cmd_processor_thread, NULL);
    pthread_cancel(g_test_framework.monitor_thread);
    pthread_join(g_test_framework.monitor_thread, NULL);
    
    test_framework_cleanup();
    cleanup_daemon();
    
    // 删除状态文件
    unlink("/tmp/ai_glass_daemon.pid");
    
    daemon_log("INFO", "后台服务已停止");
    return 0;
}

// 检查服务是否运行
int is_service_running(void) {
    // 检查PID文件和管道文件
    if (access("/tmp/ai_glass_daemon.pid", F_OK) != 0) {
        return 0;
    }
    
    if (access(FIFO_SERVER_PATH, F_OK) != 0) {
        return 0;
    }
    
    // 检查PID是否还在运行
    FILE *pid_file = fopen("/tmp/ai_glass_daemon.pid", "r");
    if (pid_file) {
        int pid;
        if (fscanf(pid_file, "%d", &pid) == 1) {
            fclose(pid_file);
            char proc_path[64];
            snprintf(proc_path, sizeof(proc_path), "/proc/%d", pid);
            return access(proc_path, F_OK) == 0;
        }
        fclose(pid_file);
    }
    
    return 0;
}